Software variables are logical constructs used by computers for processing and storing information. Software variables are typically calculated by a system processor and are generally stored in a memory for subsequent use in program execution. The software variable calculation may be as simple as a copy from a Read Only Memory (ROM) or a Random Access Memory (RAM) location, or may involve a complex manipulation by the system processor. Typically, the system processor is coupled to an Arithmetic Logic Unit (ALU), which is generally responsible for the manipulation of data stored in the memory registers, and for the loading and storage of data to and from these registers. Processors also generally contain a number of registers that are special memory locations, and can be manipulated directly by the ALU.
The type of memory used for storing software variables is generally a random access memory (RAM), typically coupled to the processor via a bus or other connection. Stored software variables may be utilized in a wide range of process control applications. Where the implementation of a software variable can be a factor in the proper functioning of a control process, the integrity of the software variable becomes an important operational consideration. Therefore, the designation “critical software variable” is often used to denote the type of software variable that may significantly affect the desired performance of a particular process.
For example, an automotive throttle control system may use critical software variables in a process that regulates the functioning of the throttle relative to the position of the accelerator pedal. Other exemplary automotive processes that might use critical software variables include fuel injection control systems, automatic braking systems and air bag control systems. In addition, there are many non-automotive applications where critical software variables could be used, such as aircraft systems, medical instrumentation, military communications, and so forth.
The successful implementation of critical software variables depends at least in part on the integrity of the critical software variables. This integrity can be adversely affected if an error should occur in either the software or hardware involved in the calculation and storage processes of the critical software variables. For example, if the RAM locations used to store a critical software variable become corrupted for any reason, the system using these critical software variables could take an incorrect action, with generally undesirable consequences. Similarly, if the hardware (e.g. ROM and/or ALU) for calculating a critical software variable includes an undetected error, the integrity of the critical software variable may be compromised and the system performance may be degraded accordingly.
It is therefore generally desirable to ensure the integrity of a critical software variable via some type of verification process before the implementation of a program that utilizes the critical software variable. Accordingly, it is desirable to provide a method and apparatus for efficiently and effectively ensuring the integrity of critical software variables stored in a system memory. In addition, it is desirable to provide a method and apparatus for ensuring the integrity of critical software variables by detecting “hard” faults that occur repetitively over multiple software test loops. Furthermore, other desirable features and characteristics of the present invention will become apparent from the subsequent detailed description of the invention and the appended claims, taken in conjunction with the accompanying drawings and this background of the invention.